/**
 * monitors/TaskMonitor.js
 * 任务监控管理器 - 核心类
 * 职责：统一管理所有监控器，提供监控接口
 */

const { fetchTaskById } = require('../core/databaseService');
const { refreshAndUpdateTask } = require('../core/taskService');

class TaskMonitor {
  constructor() {
    this.activeMonitors = new Map(); // taskId -> monitorInfo
  }

  /**
   * 启动任务监控
   * @param {string} taskId - 任务ID
   * @param {object} options - 监控选项
   */
  startMonitoring(taskId, options = {}) {
    // 避免重复监控
    if (this.activeMonitors.has(taskId)) {
      console.log(`任务 ${taskId} 已在监控中`);
      return;
    }

    const monitorInfo = {
      taskId,
      startTime: Date.now(),
      checkCount: 0,
      lastCheckTime: null,
      options
    };

    this.activeMonitors.set(taskId, monitorInfo);
    console.log(`✅ 开始监控任务: ${taskId}`);
  }

  /**
   * 停止任务监控
   * @param {string} taskId - 任务ID
   */
  stopMonitoring(taskId) {
    if (this.activeMonitors.has(taskId)) {
      this.activeMonitors.delete(taskId);
      console.log(`⏹️ 停止监控任务: ${taskId}`);
    }
  }

  /**
   * 检查单个任务
   * @param {string} taskId - 任务ID
   * @returns {Promise<object>} - 返回任务状态
   */
  async checkTask(taskId) {
    const monitorInfo = this.activeMonitors.get(taskId);
    
    try {
      // 获取任务当前状态
      const task = await fetchTaskById(taskId);
      
      if (!task) {
        console.warn(`任务 ${taskId} 不存在`);
        this.stopMonitoring(taskId);
        return null;
      }

      // 如果任务已完成或失败，停止监控
      if (task.status === 'completed' || task.status === 'failed') {
        console.log(`任务 ${taskId} 已结束 (${task.status})，停止监控`);
        this.stopMonitoring(taskId);
        return task;
      }

      // 如果没有 executeId，无法刷新
      if (!task.executeId) {
        console.warn(`任务 ${taskId} 没有 executeId，跳过检查`);
        return task;
      }

      // 更新监控信息
      if (monitorInfo) {
        monitorInfo.checkCount++;
        monitorInfo.lastCheckTime = Date.now();
      }

      // 调用 refreshAndUpdateTask 刷新状态（可能触发重试）
      console.log(`🔍 检查任务 ${taskId} (第 ${monitorInfo?.checkCount || '?'} 次)`);
      const updatedTask = await refreshAndUpdateTask(taskId);

      // 再次检查是否已完成
      if (updatedTask.status === 'completed' || updatedTask.status === 'failed') {
        this.stopMonitoring(taskId);
      }

      return updatedTask;

    } catch (error) {
      console.error(`检查任务 ${taskId} 失败:`, error);
      throw error;
    }
  }

  /**
   * 获取任务的年龄（分钟）
   * @param {object} task - 任务对象
   * @returns {number} - 任务年龄（分钟）
   */
  getTaskAge(task) {
    if (!task.createdAt) return 0;
    const now = Date.now();
    const createdTime = new Date(task.createdAt).getTime();
    return (now - createdTime) / 1000 / 60; // 转换为分钟
  }

  /**
   * 根据任务年龄获取检查间隔
   * @param {number} ageMinutes - 任务年龄（分钟）
   * @returns {number} - 检查间隔（毫秒）
   */
  getCheckInterval(ageMinutes) {
    if (ageMinutes < 5) {
      return 10000;  // 0-5分钟: 每10秒
    } else if (ageMinutes < 30) {
      return 30000;  // 5-30分钟: 每30秒
    } else {
      return 120000; // 30分钟+: 每2分钟
    }
  }

  /**
   * 获取所有正在监控的任务
   * @returns {Array} - 任务ID列表
   */
  getActiveMonitors() {
    return Array.from(this.activeMonitors.keys());
  }

  /**
   * 清理所有监控
   */
  clearAll() {
    this.activeMonitors.clear();
    console.log('🧹 清理所有监控');
  }
}

// 单例模式
let instance = null;

function getTaskMonitor() {
  if (!instance) {
    instance = new TaskMonitor();
  }
  return instance;
}

module.exports = {
  TaskMonitor,
  getTaskMonitor
};

